Clover icon

fastjson 1.2.60_preview_04

  1. Project Clover database Tue Apr 9 2024 15:48:38 CDT
  2. Package com.alibaba.fastjson.parser.deserializer

File JavaBeanDeserializer.java

 
test_strings: Feature.AllowSingleQuotes is false
test_for_issue_1188: setter not found, class com.alibaba.json.bvt.issue_1100.I...
test_notMatch: setter not found, class com.alibaba.json.bvt.parser.deser...
test_for_issue: setter not found, class com.alibaba.json.bvt.issue_2000.I...
test_for_issue: setter not found, class com.alibaba.json.bvt.bug.Bug_for_...
test_strings_: Feature.AllowSingleQuotes is false
test_0: setter not found, class com.alibaba.json.bvt.TestFlase$VO...
test_1: Feature.AllowSingleQuotes is false
test_value2: setter not found, class com.alibaba.json.bvt.parser.JSONL...
test_4: setter not found, class com.alibaba.json.bvt.parser.JSONS...
test_null: syntax error
test_PreAuthenticatedAuthenticationToken: setter not found, class org.springframework.security.web....
test_enums: Feature.AllowSingleQuotes is false
test_1: Feature.AllowSingleQuotes is false
test_special_browsecue: syntax error
test_2: Feature.AllowSingleQuotes is false
test_for_issue: setter not found, class com.alibaba.json.bvtVO.ae.huangli...
test_date: parseLong error, field : value
test_for_issue: setter not found, class com.alibaba.json.bvt.bug.Bug_for_...
test_notMatch: setter not found, class com.alibaba.json.bvt.parser.deser...
test_value: Feature.AllowSingleQuotes is false
test_0: setter not found, class com.alibaba.json.bvt.parser.Defau...
test_for_issue_decode: setter not found, class com.alibaba.json.bvt.bug.Bug_for_...
test_notMatch: setter not found, class com.alibaba.json.bvt.parser.deser...
test_dup: setter not found, class com.alibaba.json.bvt.parser.deser...
test_for_ludong: setter not found, class com.alibaba.json.bvt.bug.Bug_for_...
test_1: Feature.AllowSingleQuotes is false
test_for_issue: setter not found, class com.alibaba.json.bvt.issue_1300.I...
test_extra: setter not found, class com.alibaba.json.bvt.parser.Redun...
test_date_7: Feature.AllowSingleQuotes is false
test_for_issue: setter not found, class com.alibaba.json.bvt.issue_1200.I...
test_for_issue: setter not found, class com.alibaba.json.bvt.bug.Bug_for_...
test_e: Feature.AllowSingleQuotes is false
test_for_issue: setter not found, class com.alibaba.json.bvt.issue_1500.I...
test_notMatch: setter not found, class com.alibaba.json.bvt.parser.deser...
test_charArray: syntax error
test_for_issue: setter not found, class com.alibaba.json.bvt.bug.Bug_for_...
test_for_maiksagill: setter not found, class com.alibaba.json.bvtVO.Image, pro...
test_for_issue: setter not found, class org.springframework.security.web....
test_feature: setter not found, class com.alibaba.json.bvt.feature.Disa...
test_2: Feature.AllowSingleQuotes is false
test_deserializeUsing: syntax error
test_feature: setter not found, class com.alibaba.json.bvt.feature.Disa...
test_2: syntax error
test_notMatch: setter not found, class com.alibaba.json.bvt.parser.deser...
test_for_issue_true: setter not found, class com.alibaba.json.bvt.bug.Issue939...
test_feature2: setter not found, class com.alibaba.json.bvt.feature.Disa...
test_for_wangran: setter not found, class com.alibaba.json.bvtVO.VirtualTop...
test_2: setter not found, class com.alibaba.json.bvt.parser.JSONS...
test_0: setter not found, class org.springframework.security.oaut...
test_for_issue: setter not found, class com.alibaba.json.bvt.issue_2300.I...
test_1: Feature.AllowSingleQuotes is false
test_for_issue: setter not found, class com.alibaba.json.bvt.bug.Bug_for_...
test_matchField: setter not found, class com.alibaba.json.bvt.parser.JSONL...
test_extraWithType: setter not found, class com.alibaba.json.bvt.parser.Redun...
test_b: setter not found, class com.alibaba.json.bvt.parser.JSONL...
test_for_bug: setter not found, class com.alibaba.json.bvt.parser.bug.B...
test_for_wangran: setter not found, class com.alibaba.json.bvtVO.QueueEntit...
test_generic: Feature.AllowSingleQuotes is false
test_notMatch: setter not found, class com.alibaba.json.bvt.parser.deser...
test_for_issue: setter not found, class com.alibaba.json.bvt.issue_1200.I...
test_feature2: setter not found, class com.alibaba.json.bvt.feature.Disa...
test_0: setter not found, class com.alibaba.json.bvtVO.DataTransa...
test: setter not found, class cn.com.tx.domain.pagination.Pagin...
test_for_issue: setter not found, class com.alibaba.json.bvt.bug.Bug_for_...
test_2: Feature.AllowSingleQuotes is false
test_2: Feature.AllowSingleQuotes is false
test_for_issue_false: setter not found, class com.alibaba.json.bvt.bug.Issue939...
test_long_list: setter not found, class com.alibaba.json.bvt.parser.bug.B...
test_1: Feature.AllowSingleQuotes is false
test_parseObject_2: setter not found, class com.alibaba.json.bvt.issue_1200.I...
test_e: Feature.AllowSingleQuotes is false
test_for_issue: setter not found, class com.alibaba.json.bvt.issue_1200.I...
test_final: setter not found, class com.alibaba.json.bvt.FinalTest$VO...
test_for_hsf: setter not found, class com.alibaba.json.bvt.support.hsf....
test_SecurityContextImpl_x: setter not found, class org.springframework.security.auth...
test_not_match: setter not found, class com.alibaba.json.bvt.parser.Defau...
test_singleQuote_vo: syntax error
test_string_2: Feature.AllowSingleQuotes is false
test_2: setter not found, class com.alibaba.json.bvt.parser.JSONS...
test: setter not found, class com.alibaba.json.bvt.bug.Bug_for_...
test_0: setter not found, class com.alibaba.json.bvt.bug.Bug_for_...
test_user: setter not found, class kotlin.ranges.IntRange, property end
 

Coverage histogram

../../../../../img/srcFileCovDistChart9.png
23% of files have more coverage

Code metrics

630
958
27
1
1,633
1,426
430
0.45
35.48
27
15.93

Classes

Class Line # Actions
JavaBeanDeserializer 26 958 0% 430 196
0.878637887.9%
 

Contributing tests

This file is covered by 2006 tests. .

Source view

1    package com.alibaba.fastjson.parser.deserializer;
2   
3    import java.lang.reflect.*;
4    import java.math.BigDecimal;
5    import java.math.BigInteger;
6    import java.util.*;
7    import java.util.concurrent.ConcurrentHashMap;
8    import java.util.concurrent.ConcurrentMap;
9   
10    import com.alibaba.fastjson.JSON;
11    import com.alibaba.fastjson.JSONException;
12    import com.alibaba.fastjson.JSONObject;
13    import com.alibaba.fastjson.annotation.JSONField;
14    import com.alibaba.fastjson.parser.DefaultJSONParser;
15    import com.alibaba.fastjson.parser.DefaultJSONParser.ResolveTask;
16    import com.alibaba.fastjson.parser.Feature;
17    import com.alibaba.fastjson.parser.JSONLexer;
18    import com.alibaba.fastjson.parser.JSONLexerBase;
19    import com.alibaba.fastjson.parser.JSONToken;
20    import com.alibaba.fastjson.parser.ParseContext;
21    import com.alibaba.fastjson.parser.ParserConfig;
22    import com.alibaba.fastjson.util.FieldInfo;
23    import com.alibaba.fastjson.util.JavaBeanInfo;
24    import com.alibaba.fastjson.util.TypeUtils;
25   
 
26    public class JavaBeanDeserializer implements ObjectDeserializer {
27   
28    private final FieldDeserializer[] fieldDeserializers;
29    protected final FieldDeserializer[] sortedFieldDeserializers;
30    protected final Class<?> clazz;
31    public final JavaBeanInfo beanInfo;
32    private ConcurrentMap<String, Object> extraFieldDeserializers;
33   
34    private final Map<String, FieldDeserializer> alterNameFieldDeserializers;
35    private Map<String, FieldDeserializer> fieldDeserializerMap;
36   
37    private transient long[] smartMatchHashArray;
38    private transient short[] smartMatchHashArrayMapping;
39   
40    private transient long[] hashArray;
41    private transient short[] hashArrayMapping;
42   
 
43  0 toggle public JavaBeanDeserializer(ParserConfig config, Class<?> clazz) {
44  0 this(config, clazz, clazz);
45    }
46   
 
47  507 toggle public JavaBeanDeserializer(ParserConfig config, Class<?> clazz, Type type){
48  507 this(config //
49    , JavaBeanInfo.build(clazz, type, config.propertyNamingStrategy, config.fieldBased, config.compatibleWithJavaBean, config.isJacksonCompatible())
50    );
51    }
52   
 
53  1497 toggle public JavaBeanDeserializer(ParserConfig config, JavaBeanInfo beanInfo){
54  1497 this.clazz = beanInfo.clazz;
55  1497 this.beanInfo = beanInfo;
56   
57  1497 Map<String, FieldDeserializer> alterNameFieldDeserializers = null;
58  1497 sortedFieldDeserializers = new FieldDeserializer[beanInfo.sortedFields.length];
59  4897 for (int i = 0, size = beanInfo.sortedFields.length; i < size; ++i) {
60  3400 FieldInfo fieldInfo = beanInfo.sortedFields[i];
61  3400 FieldDeserializer fieldDeserializer = config.createFieldDeserializer(config, beanInfo, fieldInfo);
62   
63  3400 sortedFieldDeserializers[i] = fieldDeserializer;
64   
65  3400 if (size > 128) {
66  648 if (fieldDeserializerMap == null) {
67  3 fieldDeserializerMap = new HashMap<String, FieldDeserializer>();
68    }
69  648 fieldDeserializerMap.put(fieldInfo.name, fieldDeserializer);
70    }
71   
72  3400 for (String name : fieldInfo.alternateNames) {
73  7 if (alterNameFieldDeserializers == null) {
74  3 alterNameFieldDeserializers = new HashMap<String, FieldDeserializer>();
75    }
76  7 alterNameFieldDeserializers.put(name, fieldDeserializer);
77    }
78    }
79  1497 this.alterNameFieldDeserializers = alterNameFieldDeserializers;
80   
81  1497 fieldDeserializers = new FieldDeserializer[beanInfo.fields.length];
82  4897 for (int i = 0, size = beanInfo.fields.length; i < size; ++i) {
83  3400 FieldInfo fieldInfo = beanInfo.fields[i];
84  3400 FieldDeserializer fieldDeserializer = getFieldDeserializer(fieldInfo.name);
85  3400 fieldDeserializers[i] = fieldDeserializer;
86    }
87    }
88   
 
89  17327 toggle public FieldDeserializer getFieldDeserializer(String key) {
90  17327 return getFieldDeserializer(key, null);
91    }
92   
 
93  48041 toggle public FieldDeserializer getFieldDeserializer(String key, int[] setFlags) {
94  48041 if (key == null) {
95  1 return null;
96    }
97   
98  48040 if (fieldDeserializerMap != null) {
99  648 FieldDeserializer fieldDeserializer = fieldDeserializerMap.get(key);
100  648 if (fieldDeserializer != null) {
101  648 return fieldDeserializer;
102    }
103    }
104   
105  47392 int low = 0;
106  47392 int high = sortedFieldDeserializers.length - 1;
107   
108  114856 while (low <= high) {
109  114668 int mid = (low + high) >>> 1;
110   
111  114668 String fieldName = sortedFieldDeserializers[mid].fieldInfo.name;
112   
113  114668 int cmp = fieldName.compareTo(key);
114   
115  114668 if (cmp < 0) {
116  42259 low = mid + 1;
117  72409 } else if (cmp > 0) {
118  25205 high = mid - 1;
119    } else {
120  47204 if (isSetFlag(mid, setFlags)) {
121  0 return null;
122    }
123   
124  47204 return sortedFieldDeserializers[mid]; // key found
125    }
126    }
127   
128  188 if(this.alterNameFieldDeserializers != null){
129  6 return this.alterNameFieldDeserializers.get(key);
130    }
131   
132  182 return null; // key not found.
133    }
134   
 
135  3 toggle public FieldDeserializer getFieldDeserializer(long hash) {
136  3 if (this.hashArray == null) {
137  3 long[] hashArray = new long[sortedFieldDeserializers.length];
138  7 for (int i = 0; i < sortedFieldDeserializers.length; i++) {
139  4 hashArray[i] = TypeUtils.fnv1a_64(sortedFieldDeserializers[i].fieldInfo.name);
140    }
141  3 Arrays.sort(hashArray);
142  3 this.hashArray = hashArray;
143    }
144   
145  3 int pos = Arrays.binarySearch(hashArray, hash);
146  3 if (pos < 0) {
147  0 return null;
148    }
149   
150  3 if (hashArrayMapping == null) {
151  3 short[] mapping = new short[hashArray.length];
152  3 Arrays.fill(mapping, (short) -1);
153  7 for (int i = 0; i < sortedFieldDeserializers.length; i++) {
154  4 int p = Arrays.binarySearch(hashArray
155    , TypeUtils.fnv1a_64(sortedFieldDeserializers[i].fieldInfo.name));
156  4 if (p >= 0) {
157  4 mapping[p] = (short) i;
158    }
159    }
160  3 hashArrayMapping = mapping;
161    }
162   
163  3 int setterIndex = hashArrayMapping[pos];
164  3 if (setterIndex != -1) {
165  3 return sortedFieldDeserializers[setterIndex];
166    }
167   
168  0 return null; // key not found.
169    }
170   
 
171  47249 toggle static boolean isSetFlag(int i, int[] setFlags) {
172  47249 if (setFlags == null) {
173  34993 return false;
174    }
175   
176  12256 int flagIndex = i / 32;
177  12256 int bitIndex = i % 32;
178  12256 if (flagIndex < setFlags.length) {
179  12256 if ((setFlags[flagIndex] & (1 << bitIndex)) != 0) {
180  3 return true;
181    }
182    }
183   
184  12253 return false;
185    }
186   
 
187  29018 toggle public Object createInstance(DefaultJSONParser parser, Type type) {
188  29018 if (type instanceof Class) {
189  28536 if (clazz.isInterface()) {
190  17 Class<?> clazz = (Class<?>) type;
191  17 ClassLoader loader = Thread.currentThread().getContextClassLoader();
192  17 final JSONObject obj = new JSONObject();
193  17 Object proxy = Proxy.newProxyInstance(loader, new Class<?>[] { clazz }, obj);
194  17 return proxy;
195    }
196    }
197   
198  29001 if (beanInfo.defaultConstructor == null && beanInfo.factoryMethod == null) {
199  98 return null;
200    }
201   
202  28903 if (beanInfo.factoryMethod != null && beanInfo.defaultConstructorParameterSize > 0) {
203  5 return null;
204    }
205   
206  28898 Object object;
207  28898 try {
208  28898 Constructor<?> constructor = beanInfo.defaultConstructor;
209  28898 if (beanInfo.defaultConstructorParameterSize == 0) {
210  28875 if (constructor != null) {
211  28874 object = constructor.newInstance();
212    } else {
213  1 object = beanInfo.factoryMethod.invoke(null);
214    }
215    } else {
216  23 ParseContext context = parser.getContext();
217  22 if (context == null || context.object == null) {
218  1 throw new JSONException("can't create non-static inner class instance.");
219    }
220   
221  21 final String typeName;
222  21 if (type instanceof Class) {
223  21 typeName = ((Class<?>) type).getName();
224    } else {
225  0 throw new JSONException("can't create non-static inner class instance.");
226    }
227   
228  21 final int lastIndex = typeName.lastIndexOf('$');
229  21 String parentClassName = typeName.substring(0, lastIndex);
230   
231  21 Object ctxObj = context.object;
232  21 String parentName = ctxObj.getClass().getName();
233   
234  21 Object param = null;
235  21 if (!parentName.equals(parentClassName)) {
236  4 ParseContext parentContext = context.parent;
237  4 if (parentContext != null
238    && parentContext.object != null
239    && ("java.util.ArrayList".equals(parentName)
240    || "java.util.List".equals(parentName)
241    || "java.util.Collection".equals(parentName)
242    || "java.util.Map".equals(parentName)
243    || "java.util.HashMap".equals(parentName))) {
244  2 parentName = parentContext.object.getClass().getName();
245  2 if (parentName.equals(parentClassName)) {
246  2 param = parentContext.object;
247    }
248    } else {
249  2 param = ctxObj;
250    }
251    } else {
252  17 param = ctxObj;
253    }
254   
255  21 if (param == null || param instanceof Collection && ((Collection)param).isEmpty()) {
256  1 throw new JSONException("can't create non-static inner class instance.");
257    }
258   
259  20 object = constructor.newInstance(param);
260    }
261    } catch (JSONException e) {
262  2 throw e;
263    } catch (Exception e) {
264  2 throw new JSONException("create instance error, class " + clazz.getName(), e);
265    }
266   
267  28894 if (parser != null //
268    && parser.lexer.isEnabled(Feature.InitStringFieldAsEmpty)) {
269  3 for (FieldInfo fieldInfo : beanInfo.fields) {
270  3 if (fieldInfo.fieldClass == String.class) {
271  3 try {
272  3 fieldInfo.set(object, "");
273    } catch (Exception e) {
274  1 throw new JSONException("create instance error, class " + clazz.getName(), e);
275    }
276    }
277    }
278    }
279   
280  28893 return object;
281    }
282   
 
283  15082465 toggle public <T> T deserialze(DefaultJSONParser parser, Type type, Object fieldName) {
284  15082465 Test failure here return deserialze(parser, type, fieldName, 0);
285    }
286   
 
287  32706 toggle public <T> T deserialze(DefaultJSONParser parser, Type type, Object fieldName, int features) {
288  32706 Test failure here return deserialze(parser, type, fieldName, null, features, null);
289    }
290   
 
291  32 toggle @SuppressWarnings({ "unchecked" })
292    public <T> T deserialzeArrayMapping(DefaultJSONParser parser, Type type, Object fieldName, Object object) {
293  32 final JSONLexer lexer = parser.lexer; // xxx
294  32 if (lexer.token() != JSONToken.LBRACKET) {
295  0 throw new JSONException("error");
296    }
297   
298  32 object = createInstance(parser, type);
299   
300  102 for (int i = 0, size = sortedFieldDeserializers.length; i < size; ++i) {
301  76 final char seperator = (i == size - 1) ? ']' : ',';
302  76 FieldDeserializer fieldDeser = sortedFieldDeserializers[i];
303  76 Class<?> fieldClass = fieldDeser.fieldInfo.fieldClass;
304  76 if (fieldClass == int.class) {
305  6 int value = lexer.scanInt(seperator);
306  6 fieldDeser.setValue(object, value);
307  70 } else if (fieldClass == String.class) {
308  25 String value = lexer.scanString(seperator);
309  25 fieldDeser.setValue(object, value);
310  45 } else if (fieldClass == long.class) {
311  1 long value = lexer.scanLong(seperator);
312  1 fieldDeser.setValue(object, value);
313  44 } else if (fieldClass.isEnum()) {
314  21 char ch = lexer.getCurrent();
315   
316  21 Object value;
317  21 if (ch == '\"' || ch == 'n') {
318  16 value = lexer.scanEnum(fieldClass, parser.getSymbolTable(), seperator);
319  5 } else if (ch >= '0' && ch <= '9') {
320  4 int ordinal = lexer.scanInt(seperator);
321   
322  4 EnumDeserializer enumDeser = (EnumDeserializer) ((DefaultFieldDeserializer) fieldDeser).getFieldValueDeserilizer(parser.getConfig());
323  4 value = enumDeser.valueOf(ordinal);
324    } else {
325  1 value = scanEnum(lexer, seperator);
326    }
327   
328  20 fieldDeser.setValue(object, value);
329  23 } else if (fieldClass == boolean.class) {
330  2 boolean value = lexer.scanBoolean(seperator);
331  2 fieldDeser.setValue(object, value);
332  21 } else if (fieldClass == float.class) {
333  4 float value = lexer.scanFloat(seperator);
334  4 fieldDeser.setValue(object, value);
335  17 } else if (fieldClass == double.class) {
336  4 double value = lexer.scanDouble(seperator);
337  4 fieldDeser.setValue(object, value);
338  13 } else if (fieldClass == java.util.Date.class && lexer.getCurrent() == '1') {
339  2 long longValue = lexer.scanLong(seperator);
340  2 fieldDeser.setValue(object, new java.util.Date(longValue));
341  11 } else if (fieldClass == BigDecimal.class) {
342  0 BigDecimal value = lexer.scanDecimal(seperator);
343  0 fieldDeser.setValue(object, value);
344    } else {
345  11 lexer.nextToken(JSONToken.LBRACKET);
346  11 Object value = parser.parseObject(fieldDeser.fieldInfo.fieldType, fieldDeser.fieldInfo.name);
347  11 fieldDeser.setValue(object, value);
348   
349  11 if (lexer.token() == JSONToken.RBRACKET) {
350  5 break;
351    }
352   
353  6 check(lexer, seperator == ']' ? JSONToken.RBRACKET : JSONToken.COMMA);
354    // parser.accept(seperator == ']' ? JSONToken.RBRACKET : JSONToken.COMMA);
355    }
356    }
357  31 lexer.nextToken(JSONToken.COMMA);
358   
359  27 return (T) object;
360    }
361   
 
362  12 toggle protected void check(final JSONLexer lexer, int token) {
363  12 if (lexer.token() != token) {
364  2 throw new JSONException("syntax error");
365    }
366    }
367   
 
368  1 toggle protected Enum<?> scanEnum(JSONLexer lexer, char seperator) {
369  1 throw new JSONException("illegal enum. " + lexer.info());
370    }
371   
 
372  38720 toggle @SuppressWarnings({ "unchecked", "rawtypes" })
373    protected <T> T deserialze(DefaultJSONParser parser, //
374    Type type, //
375    Object fieldName, //
376    Object object, //
377    int features, //
378    int[] setFlags) {
379  38720 if (type == JSON.class || type == JSONObject.class) {
380  3 return (T) parser.parse();
381    }
382   
383  38717 final JSONLexerBase lexer = (JSONLexerBase) parser.lexer; // xxx
384  38717 final ParserConfig config = parser.getConfig();
385   
386  38717 int token = lexer.token();
387  38717 if (token == JSONToken.NULL) {
388  6 lexer.nextToken(JSONToken.COMMA);
389  6 return null;
390    }
391   
392  38711 ParseContext context = parser.getContext();
393  38711 if (object != null && context != null) {
394  6014 context = context.parent;
395    }
396  38711 ParseContext childContext = null;
397   
398  38711 try {
399  38711 Map<String, Object> fieldValues = null;
400   
401  38711 if (token == JSONToken.RBRACE) {
402  29 lexer.nextToken(JSONToken.COMMA);
403  29 if (object == null) {
404  9 object = createInstance(parser, type);
405    }
406  29 return (T) object;
407    }
408   
409  38682 if (token == JSONToken.LBRACKET) {
410  35 final int mask = Feature.SupportArrayToBean.mask;
411  35 boolean isSupportArrayToBean = (beanInfo.parserFeatures & mask) != 0 //
412    || lexer.isEnabled(Feature.SupportArrayToBean) //
413    || (features & mask) != 0
414    ;
415  35 if (isSupportArrayToBean) {
416  32 return deserialzeArrayMapping(parser, type, fieldName, object);
417    }
418    }
419   
420  38650 if (token != JSONToken.LBRACE && token != JSONToken.COMMA) {
421  14 if (lexer.isBlankInput()) {
422  1 return null;
423    }
424   
425  13 if (token == JSONToken.LITERAL_STRING) {
426  6 String strVal = lexer.stringVal();
427  6 if (strVal.length() == 0) {
428  2 lexer.nextToken();
429  2 return null;
430    }
431   
432  4 if (beanInfo.jsonType != null) {
433  1 for (Class<?> seeAlsoClass : beanInfo.jsonType.seeAlso()) {
434  2 if (Enum.class.isAssignableFrom(seeAlsoClass)) {
435  2 try {
436  2 Enum<?> e = Enum.valueOf((Class<Enum>) seeAlsoClass, strVal);
437  1 return (T) e;
438    } catch (IllegalArgumentException e) {
439    // skip
440    }
441    }
442    }
443    }
444  7 } else if (token == JSONToken.LITERAL_ISO8601_DATE) {
445  0 Calendar calendar = lexer.getCalendar();
446    }
447   
448  10 if (token == JSONToken.LBRACKET && lexer.getCurrent() == ']') {
449  2 lexer.next();
450  2 lexer.nextToken();
451  2 return null;
452    }
453   
454  8 if (beanInfo.factoryMethod != null && beanInfo.fields.length == 1) {
455  3 try {
456  3 FieldInfo field = beanInfo.fields[0];
457  3 if (field.fieldClass == Integer.class) {
458  2 if (token == JSONToken.LITERAL_INT) {
459  2 int intValue = lexer.intValue();
460  2 lexer.nextToken();
461  2 return (T) createFactoryInstance(config, intValue);
462    }
463  1 } else if (field.fieldClass == String.class) {
464  1 if (token == JSONToken.LITERAL_STRING) {
465  1 String stringVal = lexer.stringVal();
466  1 lexer.nextToken();
467  1 return (T) createFactoryInstance(config, stringVal);
468    }
469    }
470    } catch (Exception ex) {
471  0 throw new JSONException(ex.getMessage(), ex);
472    }
473    }
474   
475  5 StringBuilder buf = (new StringBuilder()) //
476    .append("syntax error, expect {, actual ") //
477    .append(lexer.tokenName()) //
478    .append(", pos ") //
479    .append(lexer.pos());
480   
481  5 if (fieldName instanceof String) {
482  2 buf //
483    .append(", fieldName ") //
484    .append(fieldName);
485    }
486   
487  5 buf.append(", fastjson-version ").append(JSON.VERSION);
488   
489  5 throw new JSONException(buf.toString());
490    }
491   
492  38636 if (parser.resolveStatus == DefaultJSONParser.TypeNameRedirect) {
493  248 parser.resolveStatus = DefaultJSONParser.NONE;
494    }
495   
496  38636 String typeKey = beanInfo.typeKey;
497  38636 for (int fieldIndex = 0, notMatchCount = 0;; fieldIndex++) {
498  60317 String key = null;
499  60317 FieldDeserializer fieldDeser = null;
500  60317 FieldInfo fieldInfo = null;
501  60317 Class<?> fieldClass = null;
502  60317 JSONField feildAnnotation = null;
503  60317 boolean customDeserilizer = false;
504  60317 if (fieldIndex < sortedFieldDeserializers.length && notMatchCount < 16) {
505  55767 fieldDeser = sortedFieldDeserializers[fieldIndex];
506  55767 fieldInfo = fieldDeser.fieldInfo;
507  55767 fieldClass = fieldInfo.fieldClass;
508  55767 feildAnnotation = fieldInfo.getAnnotation();
509  55767 if (feildAnnotation != null && fieldDeser instanceof DefaultFieldDeserializer) {
510  394 customDeserilizer = ((DefaultFieldDeserializer) fieldDeser).customDeserilizer;
511    }
512    }
513   
514  60317 boolean matchField = false;
515  60317 boolean valueParsed = false;
516   
517  60317 Object fieldValue = null;
518  60317 if (fieldDeser != null) {
519  55767 char[] name_chars = fieldInfo.name_chars;
520  55767 if (customDeserilizer && lexer.matchField(name_chars)) {
521  4 matchField = true;
522  55763 } else if (fieldClass == int.class || fieldClass == Integer.class) {
523  3033 int intVal = lexer.scanFieldInt(name_chars);
524  3033 if (intVal == 0 && lexer.matchStat == JSONLexer.VALUE_NULL) {
525  0 fieldValue = null;
526    } else {
527  3033 fieldValue = intVal;
528    }
529   
530  3033 if (lexer.matchStat > 0) {
531  1379 matchField = true;
532  1379 valueParsed = true;
533  1654 } else if (lexer.matchStat == JSONLexer.NOT_MATCH_NAME) {
534  1302 notMatchCount++;
535  1302 continue;
536    }
537  52730 } else if (fieldClass == long.class || fieldClass == Long.class) {
538  20850 long longVal = lexer.scanFieldLong(name_chars);
539  20850 if (longVal == 0 && lexer.matchStat == JSONLexer.VALUE_NULL) {
540  0 fieldValue = null;
541    } else {
542  20850 fieldValue = longVal;
543    }
544   
545  20850 if (lexer.matchStat > 0) {
546  16880 matchField = true;
547  16880 valueParsed = true;
548  3970 } else if (lexer.matchStat == JSONLexer.NOT_MATCH_NAME) {
549  330 notMatchCount++;
550  330 continue;
551    }
552  31880 } else if (fieldClass == String.class) {
553  15972 fieldValue = lexer.scanFieldString(name_chars);
554   
555  15970 if (lexer.matchStat > 0) {
556  15522 matchField = true;
557  15522 valueParsed = true;
558  448 } else if (lexer.matchStat == JSONLexer.NOT_MATCH_NAME) {
559  366 notMatchCount++;
560  366 continue;
561    }
562  15908 } else if (fieldClass == java.util.Date.class && fieldInfo.format == null) {
563  531 fieldValue = lexer.scanFieldDate(name_chars);
564   
565  530 if (lexer.matchStat > 0) {
566  71 matchField = true;
567  71 valueParsed = true;
568  459 } else if (lexer.matchStat == JSONLexer.NOT_MATCH_NAME) {
569  423 notMatchCount++;
570  423 continue;
571    }
572  15377 } else if (fieldClass == BigDecimal.class) {
573  30 fieldValue = lexer.scanFieldDecimal(name_chars);
574   
575  30 if (lexer.matchStat > 0) {
576  9 matchField = true;
577  9 valueParsed = true;
578  21 } else if (lexer.matchStat == JSONLexer.NOT_MATCH_NAME) {
579  18 notMatchCount++;
580  18 continue;
581    }
582  15347 } else if (fieldClass == BigInteger.class) {
583  9 fieldValue = lexer.scanFieldBigInteger(name_chars);
584   
585  9 if (lexer.matchStat > 0) {
586  4 matchField = true;
587  4 valueParsed = true;
588  5 } else if (lexer.matchStat == JSONLexer.NOT_MATCH_NAME) {
589  2 notMatchCount++;
590  2 continue;
591    }
592  15338 } else if (fieldClass == boolean.class || fieldClass == Boolean.class) {
593  234 boolean booleanVal = lexer.scanFieldBoolean(name_chars);
594   
595  234 if (lexer.matchStat == JSONLexer.VALUE_NULL) {
596  0 fieldValue = null;
597    } else {
598  234 fieldValue = booleanVal;
599    }
600   
601  234 if (lexer.matchStat > 0) {
602  86 matchField = true;
603  86 valueParsed = true;
604  148 } else if (lexer.matchStat == JSONLexer.NOT_MATCH_NAME) {
605  103 notMatchCount++;
606  103 continue;
607    }
608  15104 } else if (fieldClass == float.class || fieldClass == Float.class) {
609  1115 float floatVal = lexer.scanFieldFloat(name_chars);
610  1115 if (floatVal == 0 && lexer.matchStat == JSONLexer.VALUE_NULL) {
611  5 fieldValue = null;
612    } else {
613  1110 fieldValue = floatVal;
614    }
615   
616  1115 if (lexer.matchStat > 0) {
617  1053 matchField = true;
618  1053 valueParsed = true;
619  62 } else if (lexer.matchStat == JSONLexer.NOT_MATCH_NAME) {
620  42 notMatchCount++;
621  42 continue;
622    }
623  13989 } else if (fieldClass == double.class || fieldClass == Double.class) {
624  2160 double doubleVal = lexer.scanFieldDouble(name_chars);
625  2160 if (doubleVal == 0 && lexer.matchStat == JSONLexer.VALUE_NULL) {
626  5 fieldValue = null;
627    } else {
628  2155 fieldValue = doubleVal;
629    }
630   
631  2160 if (lexer.matchStat > 0) {
632  2091 matchField = true;
633  2091 valueParsed = true;
634  69 } else if (lexer.matchStat == JSONLexer.NOT_MATCH_NAME) {
635  49 notMatchCount++;
636  49 continue;
637    }
638  11829 } else if (fieldClass.isEnum() //
639    && parser.getConfig().getDeserializer(fieldClass) instanceof EnumDeserializer
640    && (feildAnnotation == null || feildAnnotation.deserializeUsing() == Void.class)
641    ) {
642  8276 if (fieldDeser instanceof DefaultFieldDeserializer) {
643  8276 ObjectDeserializer fieldValueDeserilizer = ((DefaultFieldDeserializer) fieldDeser).fieldValueDeserilizer;
644  8276 fieldValue = this.scanEnum(lexer, name_chars, fieldValueDeserilizer);
645   
646  8276 if (lexer.matchStat > 0) {
647  4126 matchField = true;
648  4126 valueParsed = true;
649  4150 } else if (lexer.matchStat == JSONLexer.NOT_MATCH_NAME) {
650  14 notMatchCount++;
651  14 continue;
652    }
653    }
654  3553 } else if (fieldClass == int[].class) {
655  9 fieldValue = lexer.scanFieldIntArray(name_chars);
656   
657  9 if (lexer.matchStat > 0) {
658  7 matchField = true;
659  7 valueParsed = true;
660  2 } else if (lexer.matchStat == JSONLexer.NOT_MATCH_NAME) {
661  1 notMatchCount++;
662  1 continue;
663    }
664  3544 } else if (fieldClass == float[].class) {
665  4 fieldValue = lexer.scanFieldFloatArray(name_chars);
666   
667  4 if (lexer.matchStat > 0) {
668  2 matchField = true;
669  2 valueParsed = true;
670  2 } else if (lexer.matchStat == JSONLexer.NOT_MATCH_NAME) {
671  1 notMatchCount++;
672  1 continue;
673    }
674  3540 } else if (fieldClass == float[][].class) {
675  3 fieldValue = lexer.scanFieldFloatArray2(name_chars);
676   
677  3 if (lexer.matchStat > 0) {
678  2 matchField = true;
679  2 valueParsed = true;
680  1 } else if (lexer.matchStat == JSONLexer.NOT_MATCH_NAME) {
681  0 notMatchCount++;
682  0 continue;
683    }
684  3537 } else if (lexer.matchField(name_chars)) {
685  1313 matchField = true;
686    } else {
687  2224 continue;
688    }
689    }
690   
691  55439 if (!matchField) {
692  12890 Test failure here key = lexer.scanSymbol(parser.symbolTable);
693   
694  12875 if (key == null) {
695  363 token = lexer.token();
696  363 if (token == JSONToken.RBRACE) {
697  311 lexer.nextToken(JSONToken.COMMA);
698  311 break;
699    }
700  52 if (token == JSONToken.COMMA) {
701  21 if (lexer.isEnabled(Feature.AllowArbitraryCommas)) {
702  20 continue;
703    }
704    }
705    }
706   
707  12544 if ("$ref" == key && context != null) {
708  68 lexer.nextTokenWithColon(JSONToken.LITERAL_STRING);
709  68 token = lexer.token();
710  68 if (token == JSONToken.LITERAL_STRING) {
711  67 String ref = lexer.stringVal();
712  67 if ("@".equals(ref)) {
713  3 object = context.object;
714  64 } else if ("..".equals(ref)) {
715  5 ParseContext parentContext = context.parent;
716  5 if (parentContext.object != null) {
717  3 object = parentContext.object;
718    } else {
719  2 parser.addResolveTask(new ResolveTask(parentContext, ref));
720  2 parser.resolveStatus = DefaultJSONParser.NeedToResolve;
721    }
722  59 } else if ("$".equals(ref)) {
723  14 ParseContext rootContext = context;
724  41 while (rootContext.parent != null) {
725  27 rootContext = rootContext.parent;
726    }
727   
728  14 if (rootContext.object != null) {
729  11 object = rootContext.object;
730    } else {
731  3 parser.addResolveTask(new ResolveTask(rootContext, ref));
732  3 parser.resolveStatus = DefaultJSONParser.NeedToResolve;
733    }
734    } else {
735  45 if (ref.indexOf('\\') > 0) {
736  1 StringBuilder buf = new StringBuilder();
737  83 for (int i = 0; i < ref.length(); ++i) {
738  82 char ch = ref.charAt(i);
739  82 if (ch == '\\') {
740  8 ch = ref.charAt(++i);
741    }
742  82 buf.append(ch);
743    }
744  1 ref = buf.toString();
745    }
746  45 Object refObj = parser.resolveReference(ref);
747  45 if (refObj != null) {
748  38 object = refObj;
749    } else {
750  7 parser.addResolveTask(new ResolveTask(context, ref));
751  7 parser.resolveStatus = DefaultJSONParser.NeedToResolve;
752    }
753    }
754    } else {
755  1 throw new JSONException("illegal ref, " + JSONToken.name(token));
756    }
757   
758  67 lexer.nextToken(JSONToken.RBRACE);
759  67 if (lexer.token() != JSONToken.RBRACE) {
760  1 throw new JSONException("illegal ref");
761    }
762  66 lexer.nextToken(JSONToken.COMMA);
763   
764  66 parser.setContext(context, object, fieldName);
765   
766  66 return (T) object;
767    }
768   
769  12476 if ((typeKey != null && typeKey.equals(key))
770    || JSON.DEFAULT_TYPE_KEY == key) {
771  96 lexer.nextTokenWithColon(JSONToken.LITERAL_STRING);
772  96 if (lexer.token() == JSONToken.LITERAL_STRING) {
773  96 String typeName = lexer.stringVal();
774  96 lexer.nextToken(JSONToken.COMMA);
775   
776  96 if (typeName.equals(beanInfo.typeName)|| parser.isEnabled(Feature.IgnoreAutoType)) {
777  62 if (lexer.token() == JSONToken.RBRACE) {
778  8 lexer.nextToken();
779  8 break;
780    }
781  54 continue;
782    }
783   
784   
785  34 ObjectDeserializer deserializer = getSeeAlso(config, this.beanInfo, typeName);
786  34 Class<?> userType = null;
787   
788  34 if (deserializer == null) {
789  27 Class<?> expectClass = TypeUtils.getClass(type);
790  27 userType = config.checkAutoType(typeName, expectClass, lexer.getFeatures());
791  22 deserializer = parser.getConfig().getDeserializer(userType);
792    }
793   
794  29 Test failure here Object typedObject = deserializer.deserialze(parser, userType, fieldName);
795  28 if (deserializer instanceof JavaBeanDeserializer) {
796  27 JavaBeanDeserializer javaBeanDeserializer = (JavaBeanDeserializer) deserializer;
797  27 if (typeKey != null) {
798  4 FieldDeserializer typeKeyFieldDeser = javaBeanDeserializer.getFieldDeserializer(typeKey);
799  4 typeKeyFieldDeser.setValue(typedObject, typeName);
800    }
801    }
802  28 return (T) typedObject;
803    } else {
804  0 throw new JSONException("syntax error");
805    }
806    }
807    }
808   
809  54929 if (object == null && fieldValues == null) {
810  32255 object = createInstance(parser, type);
811  32253 if (object == null) {
812  103 fieldValues = new HashMap<String, Object>(this.fieldDeserializers.length);
813    }
814  32253 childContext = parser.setContext(context, object, fieldName);
815  32253 if (setFlags == null) {
816  32253 setFlags = new int[(this.fieldDeserializers.length / 32) + 1];
817    }
818    }
819   
820  54927 if (matchField) {
821  42547 if (!valueParsed) {
822  1317 Test failure here fieldDeser.parseField(parser, object, type, fieldValues);
823    } else {
824  41230 if (object == null) {
825  122 fieldValues.put(fieldInfo.name, fieldValue);
826  41108 } else if (fieldValue == null) {
827  15 if (fieldClass != int.class //
828    && fieldClass != long.class //
829    && fieldClass != float.class //
830    && fieldClass != double.class //
831    && fieldClass != boolean.class //
832    ) {
833  10 fieldDeser.setValue(object, fieldValue);
834    }
835    } else {
836  41093 fieldDeser.setValue(object, fieldValue);
837    }
838   
839  41230 if (setFlags != null) {
840  41230 int flagIndex = fieldIndex / 32;
841  41230 int bitIndex = fieldIndex % 32;
842  41230 setFlags[flagIndex] |= (1 << bitIndex);
843    }
844   
845  41230 if (lexer.matchStat == JSONLexer.END) {
846  28608 break;
847    }
848    }
849    } else {
850  12380 Test failure here boolean match = parseField(parser, key, object, type,
851  12380 fieldValues == null ? new HashMap<String, Object>(this.fieldDeserializers.length) : fieldValues, setFlags);
852   
853  12183 if (!match) {
854  19 if (lexer.token() == JSONToken.RBRACE) {
855  10 lexer.nextToken();
856  10 break;
857    }
858   
859  9 continue;
860  12164 } else if (lexer.token() == JSONToken.COLON) {
861  0 throw new JSONException("syntax error, unexpect token ':'");
862    }
863    }
864   
865  26034 if (lexer.token() == JSONToken.COMMA) {
866  4497 continue;
867    }
868   
869  21537 if (lexer.token() == JSONToken.RBRACE) {
870  9302 lexer.nextToken(JSONToken.COMMA);
871  9302 break;
872    }
873   
874  12235 if (lexer.token() == JSONToken.IDENTIFIER || lexer.token() == JSONToken.ERROR) {
875  9 throw new JSONException("syntax error, unexpect token " + JSONToken.name(lexer.token()));
876    }
877    }
878   
879  38239 if (object == null) {
880  374 if (fieldValues == null) {
881  281 object = createInstance(parser, type);
882  277 if (childContext == null) {
883  277 childContext = parser.setContext(context, object, fieldName);
884    }
885  277 return (T) object;
886    }
887   
888  93 String[] paramNames = beanInfo.creatorConstructorParameters;
889  93 final Object[] params;
890  93 if (paramNames != null) {
891  27 params = new Object[paramNames.length];
892  92 for (int i = 0; i < paramNames.length; i++) {
893  65 String paramName = paramNames[i];
894   
895  65 Object param = fieldValues.remove(paramName);
896  65 if (param == null) {
897  8 Type fieldType = beanInfo.creatorConstructorParameterTypes[i];
898  8 FieldInfo fieldInfo = beanInfo.fields[i];
899  8 if (fieldType == byte.class) {
900  0 param = (byte) 0;
901  8 } else if (fieldType == short.class) {
902  0 param = (short) 0;
903  8 } else if (fieldType == int.class) {
904  1 param = 0;
905  7 } else if (fieldType == long.class) {
906  0 param = 0L;
907  7 } else if (fieldType == float.class) {
908  0 param = 0F;
909  7 } else if (fieldType == double.class) {
910  0 param = 0D;
911  7 } else if (fieldType == boolean.class) {
912  0 param = Boolean.FALSE;
913  7 } else if (fieldType == String.class
914    && (fieldInfo.parserFeatures & Feature.InitStringFieldAsEmpty.mask) != 0) {
915  0 param = "";
916    }
917    } else {
918  57 if (beanInfo.creatorConstructorParameterTypes != null && i < beanInfo.creatorConstructorParameterTypes.length) {
919  57 Type paramType = beanInfo.creatorConstructorParameterTypes[i];
920  57 if (paramType instanceof Class) {
921  57 Class paramClass = (Class) paramType;
922  57 if (!paramClass.isInstance(param)) {
923  10 if (param instanceof List) {
924  1 List list = (List) param;
925  1 if (list.size() == 1) {
926  1 Object first = list.get(0);
927  1 if (paramClass.isInstance(first)) {
928  1 param = list.get(0);
929    }
930    }
931    }
932    }
933    }
934    }
935    }
936  65 params[i] = param;
937    }
938    } else {
939  66 FieldInfo[] fieldInfoList = beanInfo.fields;
940  66 int size = fieldInfoList.length;
941  66 params = new Object[size];
942  221 for (int i = 0; i < size; ++i) {
943  155 FieldInfo fieldInfo = fieldInfoList[i];
944  155 Object param = fieldValues.get(fieldInfo.name);
945  155 if (param == null) {
946  35 Type fieldType = fieldInfo.fieldType;
947  35 if (fieldType == byte.class) {
948  1 param = (byte) 0;
949  34 } else if (fieldType == short.class) {
950  1 param = (short) 0;
951  33 } else if (fieldType == int.class) {
952  3 param = 0;
953  30 } else if (fieldType == long.class) {
954  1 param = 0L;
955  29 } else if (fieldType == float.class) {
956  1 param = 0F;
957  28 } else if (fieldType == double.class) {
958  1 param = 0D;
959  27 } else if (fieldType == boolean.class) {
960  10 param = Boolean.FALSE;
961  17 } else if (fieldType == String.class
962    && (fieldInfo.parserFeatures & Feature.InitStringFieldAsEmpty.mask) != 0) {
963  2 param = "";
964    }
965    }
966  155 params[i] = param;
967    }
968    }
969   
970  93 if (beanInfo.creatorConstructor != null) {
971  84 boolean hasNull = false;
972  84 if (beanInfo.kotlin) {
973  69 for (int i = 0; i < params.length; i++) {
974  51 if (params[i] == null && beanInfo.fields != null && i < beanInfo.fields.length) {
975  4 FieldInfo fieldInfo = beanInfo.fields[i];
976  4 if (fieldInfo.fieldClass == String.class) {
977  2 hasNull = true;
978    }
979  4 break;
980    }
981    }
982    }
983   
984  84 try {
985  84 if (hasNull && beanInfo.kotlinDefaultConstructor != null) {
986  2 object = beanInfo.kotlinDefaultConstructor.newInstance(new Object[0]);
987   
988  20 for (int i = 0; i < params.length; i++) {
989  18 final Object param = params[i];
990  18 if (param != null && beanInfo.fields != null && i < beanInfo.fields.length) {
991  13 FieldInfo fieldInfo = beanInfo.fields[i];
992  13 fieldInfo.set(object, param);
993    }
994    }
995    } else {
996  82 object = beanInfo.creatorConstructor.newInstance(params);
997    }
998    } catch (Exception e) {
999  1 throw new JSONException("create instance error, " + paramNames + ", "
1000    + beanInfo.creatorConstructor.toGenericString(), e);
1001    }
1002   
1003  83 if (paramNames != null) {
1004  27 for (Map.Entry<String, Object> entry : fieldValues.entrySet()) {
1005  10 FieldDeserializer fieldDeserializer = getFieldDeserializer(entry.getKey());
1006  10 if (fieldDeserializer != null) {
1007  10 fieldDeserializer.setValue(object, entry.getValue());
1008    }
1009    }
1010    }
1011  9 } else if (beanInfo.factoryMethod != null) {
1012  5 try {
1013  5 object = beanInfo.factoryMethod.invoke(null, params);
1014    } catch (Exception e) {
1015  1 throw new JSONException("create factory method error, " + beanInfo.factoryMethod.toString(), e);
1016    }
1017    }
1018   
1019  91 if (childContext != null) {
1020  91 childContext.object = object;
1021    }
1022    }
1023   
1024  37956 Method buildMethod = beanInfo.buildMethod;
1025  37956 if (buildMethod == null) {
1026  37943 return (T) object;
1027    }
1028   
1029   
1030  13 Object builtObj;
1031  13 try {
1032  13 builtObj = buildMethod.invoke(object);
1033    } catch (Exception e) {
1034  2 throw new JSONException("build object error", e);
1035    }
1036   
1037  11 return (T) builtObj;
1038    } finally {
1039  38711 if (childContext != null) {
1040  32510 childContext.object = object;
1041    }
1042  38711 parser.setContext(context);
1043    }
1044    }
1045   
 
1046  14446 toggle protected Enum scanEnum(JSONLexerBase lexer, char[] name_chars, ObjectDeserializer fieldValueDeserilizer) {
1047  14446 EnumDeserializer enumDeserializer = null;
1048  14446 if (fieldValueDeserilizer instanceof EnumDeserializer) {
1049  14415 enumDeserializer = (EnumDeserializer) fieldValueDeserilizer;
1050    }
1051   
1052  14446 if (enumDeserializer == null) {
1053  31 lexer.matchStat = JSONLexer.NOT_MATCH;
1054  31 return null;
1055    }
1056   
1057  14415 long enumNameHashCode = lexer.scanEnumSymbol(name_chars);
1058  14415 if (lexer.matchStat > 0) {
1059  8247 Enum e = enumDeserializer.getEnumByHashCode(enumNameHashCode);
1060  8247 if (e == null) {
1061  8 if (enumNameHashCode == 0xcbf29ce484222325L) {
1062  3 return null;
1063    }
1064   
1065  5 if (lexer.isEnabled(Feature.ErrorOnEnumNotMatch)) {
1066  1 throw new JSONException("not match enum value, " + enumDeserializer.enumClass);
1067    }
1068    }
1069   
1070  8243 return e;
1071    } else {
1072  6168 return null;
1073    }
1074    }
1075   
 
1076  0 toggle public boolean parseField(DefaultJSONParser parser, String key, Object object, Type objectType,
1077    Map<String, Object> fieldValues) {
1078  0 return parseField(parser, key, object, objectType, fieldValues, null);
1079    }
1080   
 
1081  12380 toggle public boolean parseField(DefaultJSONParser parser, String key, Object object, Type objectType,
1082    Map<String, Object> fieldValues, int[] setFlags) {
1083  12380 JSONLexer lexer = parser.lexer; // xxx
1084   
1085  12380 final int disableFieldSmartMatchMask = Feature.DisableFieldSmartMatch.mask;
1086  12380 FieldDeserializer fieldDeserializer;
1087  12376 if (lexer.isEnabled(disableFieldSmartMatchMask) || (this.beanInfo.parserFeatures & disableFieldSmartMatchMask) != 0) {
1088  0 fieldDeserializer = getFieldDeserializer(key);
1089    } else {
1090  12376 fieldDeserializer = smartMatch(key, setFlags);
1091    }
1092   
1093  12380 final int mask = Feature.SupportNonPublicField.mask;
1094  12380 if (fieldDeserializer == null
1095    && (lexer.isEnabled(mask)
1096    || (this.beanInfo.parserFeatures & mask) != 0)) {
1097  4 if (this.extraFieldDeserializers == null) {
1098  3 ConcurrentHashMap extraFieldDeserializers = new ConcurrentHashMap<String, Object>(1, 0.75f, 1);
1099  7 for (Class c = this.clazz; c != null && c != Object.class; c = c.getSuperclass()) {
1100  4 Field[] fields = c.getDeclaredFields();
1101  4 for (Field field : fields) {
1102  4 String fieldName = field.getName();
1103  4 if (this.getFieldDeserializer(fieldName) != null) {
1104  0 continue;
1105    }
1106  4 int fieldModifiers = field.getModifiers();
1107  4 if ((fieldModifiers & Modifier.FINAL) != 0 || (fieldModifiers & Modifier.STATIC) != 0) {
1108  0 continue;
1109    }
1110  4 extraFieldDeserializers.put(fieldName, field);
1111    }
1112    }
1113  3 this.extraFieldDeserializers = extraFieldDeserializers;
1114    }
1115   
1116  4 Object deserOrField = extraFieldDeserializers.get(key);
1117  4 if (deserOrField != null) {
1118  4 if (deserOrField instanceof FieldDeserializer) {
1119  0 fieldDeserializer = ((FieldDeserializer) deserOrField);
1120    } else {
1121  4 Field field = (Field) deserOrField;
1122  4 field.setAccessible(true);
1123  4 FieldInfo fieldInfo = new FieldInfo(key, field.getDeclaringClass(), field.getType(), field.getGenericType(), field, 0, 0, 0);
1124  4 fieldDeserializer = new DefaultFieldDeserializer(parser.getConfig(), clazz, fieldInfo);
1125  4 extraFieldDeserializers.put(key, fieldDeserializer);
1126    }
1127    }
1128    }
1129   
1130  12380 if (fieldDeserializer == null) {
1131  125 if (!lexer.isEnabled(Feature.IgnoreNotMatch)) {
1132  93 Test failure here throw new JSONException("setter not found, class " + clazz.getName() + ", property " + key);
1133    }
1134   
1135  32 int fieldIndex = -1;
1136  85 for (int i = 0; i < this.sortedFieldDeserializers.length; i++) {
1137  53 FieldDeserializer fieldDeser = this.sortedFieldDeserializers[i];
1138   
1139  53 FieldInfo fieldInfo = fieldDeser.fieldInfo;
1140  53 if (fieldInfo.unwrapped //
1141    && fieldDeser instanceof DefaultFieldDeserializer) {
1142  12 if (fieldInfo.field != null) {
1143  10 DefaultFieldDeserializer defaultFieldDeserializer = (DefaultFieldDeserializer) fieldDeser;
1144  10 ObjectDeserializer fieldValueDeser = defaultFieldDeserializer.getFieldValueDeserilizer(parser.getConfig());
1145  10 if (fieldValueDeser instanceof JavaBeanDeserializer) {
1146  2 JavaBeanDeserializer javaBeanFieldValueDeserializer = (JavaBeanDeserializer) fieldValueDeser;
1147  2 FieldDeserializer unwrappedFieldDeser = javaBeanFieldValueDeserializer.getFieldDeserializer(key);
1148  2 if (unwrappedFieldDeser != null) {
1149  2 Object fieldObject;
1150  2 try {
1151  2 fieldObject = fieldInfo.field.get(object);
1152  2 if (fieldObject == null) {
1153  1 fieldObject = ((JavaBeanDeserializer) fieldValueDeser).createInstance(parser, fieldInfo.fieldType);
1154  1 fieldDeser.setValue(object, fieldObject);
1155    }
1156  2 lexer.nextTokenWithColon(defaultFieldDeserializer.getFastMatchToken());
1157  2 unwrappedFieldDeser.parseField(parser, fieldObject, objectType, fieldValues);
1158  2 fieldIndex = i;
1159    } catch (Exception e) {
1160  0 throw new JSONException("parse unwrapped field error.", e);
1161    }
1162    }
1163  8 } else if (fieldValueDeser instanceof MapDeserializer) {
1164  8 MapDeserializer javaBeanFieldValueDeserializer = (MapDeserializer) fieldValueDeser;
1165   
1166  8 Map fieldObject;
1167  8 try {
1168  8 fieldObject = (Map) fieldInfo.field.get(object);
1169  8 if (fieldObject == null) {
1170  0 fieldObject = javaBeanFieldValueDeserializer.createMap(fieldInfo.fieldType);
1171  0 fieldDeser.setValue(object, fieldObject);
1172    }
1173   
1174  8 lexer.nextTokenWithColon();
1175  8 Object fieldValue = parser.parse(key);
1176  8 fieldObject.put(key, fieldValue);
1177    } catch (Exception e) {
1178  0 throw new JSONException("parse unwrapped field error.", e);
1179    }
1180  8 fieldIndex = i;
1181    }
1182  2 } else if (fieldInfo.method.getParameterTypes().length == 2) {
1183  2 lexer.nextTokenWithColon();
1184  2 Object fieldValue = parser.parse(key);
1185  2 try {
1186  2 fieldInfo.method.invoke(object, key, fieldValue);
1187    } catch (Exception e) {
1188  0 throw new JSONException("parse unwrapped field error.", e);
1189    }
1190  2 fieldIndex = i;
1191    }
1192    }
1193    }
1194   
1195  32 if (fieldIndex != -1) {
1196  12 if (setFlags != null) {
1197  12 int flagIndex = fieldIndex / 32;
1198  12 int bitIndex = fieldIndex % 32;
1199  12 setFlags[flagIndex] |= (1 << bitIndex);
1200    }
1201  12 return true;
1202    }
1203   
1204  20 parser.parseExtra(object, key);
1205   
1206  19 return false;
1207    }
1208   
1209  12255 int fieldIndex = -1;
1210  30435 for (int i = 0; i < sortedFieldDeserializers.length; ++i) {
1211  30431 if (sortedFieldDeserializers[i] == fieldDeserializer) {
1212  12251 fieldIndex = i;
1213  12251 break;
1214    }
1215    }
1216  12255 if (fieldIndex != -1 && setFlags != null && key.startsWith("_")) {
1217  4 if (isSetFlag(fieldIndex, setFlags)) {
1218  0 parser.parseExtra(object, key);
1219  0 return false;
1220    }
1221    }
1222   
1223  12255 Test failure here lexer.nextTokenWithColon(fieldDeserializer.getFastMatchToken());
1224   
1225  12224 Test failure here fieldDeserializer.parseField(parser, object, objectType, fieldValues);
1226   
1227  12152 if (setFlags != null) {
1228  12152 int flagIndex = fieldIndex / 32;
1229  12152 int bitIndex = fieldIndex % 32;
1230  12152 setFlags[flagIndex] |= (1 << bitIndex);
1231    }
1232   
1233  12152 return true;
1234    }
1235   
 
1236  18370 toggle public FieldDeserializer smartMatch(String key) {
1237  18370 return smartMatch(key, null);
1238    }
1239   
 
1240  30746 toggle public FieldDeserializer smartMatch(String key, int[] setFlags) {
1241  30746 if (key == null) {
1242  32 return null;
1243    }
1244   
1245  30714 FieldDeserializer fieldDeserializer = getFieldDeserializer(key, setFlags);
1246   
1247  30714 if (fieldDeserializer == null) {
1248  134 long smartKeyHash = TypeUtils.fnv1a_64_lower(key);
1249  134 if (this.smartMatchHashArray == null) {
1250  102 long[] hashArray = new long[sortedFieldDeserializers.length];
1251  345 for (int i = 0; i < sortedFieldDeserializers.length; i++) {
1252  243 hashArray[i] = TypeUtils.fnv1a_64_lower(sortedFieldDeserializers[i].fieldInfo.name);
1253    }
1254  102 Arrays.sort(hashArray);
1255  102 this.smartMatchHashArray = hashArray;
1256    }
1257   
1258    // smartMatchHashArrayMapping
1259  134 int pos = Arrays.binarySearch(smartMatchHashArray, smartKeyHash);
1260  134 boolean is = false;
1261  ? if (pos < 0 && (is = key.startsWith("is"))) {
1262  9 smartKeyHash = TypeUtils.fnv1a_64_lower(key.substring(2));
1263  9 pos = Arrays.binarySearch(smartMatchHashArray, smartKeyHash);
1264    }
1265   
1266  134 if (pos >= 0) {
1267  41 if (smartMatchHashArrayMapping == null) {
1268  30 short[] mapping = new short[smartMatchHashArray.length];
1269  30 Arrays.fill(mapping, (short) -1);
1270  91 for (int i = 0; i < sortedFieldDeserializers.length; i++) {
1271  61 int p = Arrays.binarySearch(smartMatchHashArray
1272    , TypeUtils.fnv1a_64_lower(sortedFieldDeserializers[i].fieldInfo.name));
1273  61 if (p >= 0) {
1274  61 mapping[p] = (short) i;
1275    }
1276    }
1277  30 smartMatchHashArrayMapping = mapping;
1278    }
1279   
1280  41 int deserIndex = smartMatchHashArrayMapping[pos];
1281  41 if (deserIndex != -1) {
1282  41 if (!isSetFlag(deserIndex, setFlags)) {
1283  38 fieldDeserializer = sortedFieldDeserializers[deserIndex];
1284    }
1285    }
1286    }
1287   
1288  134 if (fieldDeserializer != null) {
1289  38 FieldInfo fieldInfo = fieldDeserializer.fieldInfo;
1290  37 if ((fieldInfo.parserFeatures & Feature.DisableFieldSmartMatch.mask) != 0) {
1291  0 return null;
1292    }
1293   
1294  37 Class fieldClass = fieldInfo.fieldClass;
1295  36 if (is && (fieldClass != boolean.class && fieldClass != Boolean.class)) {
1296  0 fieldDeserializer = null;
1297    }
1298    }
1299    }
1300   
1301   
1302  30713 return fieldDeserializer;
1303    }
1304   
 
1305  62975 toggle public int getFastMatchToken() {
1306  62975 return JSONToken.LBRACE;
1307    }
1308   
 
1309  3 toggle private Object createFactoryInstance(ParserConfig config, Object value) //
1310    throws IllegalArgumentException,
1311    IllegalAccessException,
1312    InvocationTargetException {
1313  3 return beanInfo.factoryMethod.invoke(null, value);
1314    }
1315   
 
1316  3661 toggle public Object createInstance(Map<String, Object> map, ParserConfig config) //
1317    throws IllegalArgumentException,
1318    IllegalAccessException,
1319    InvocationTargetException {
1320  3661 Object object = null;
1321   
1322  3661 if (beanInfo.creatorConstructor == null && beanInfo.factoryMethod == null) {
1323  3653 object = createInstance(null, clazz);
1324   
1325  3652 for (Map.Entry<String, Object> entry : map.entrySet()) {
1326  18364 String key = entry.getKey();
1327  18364 Object value = entry.getValue();
1328   
1329  18364 FieldDeserializer fieldDeser = smartMatch(key);
1330  18364 if (fieldDeser == null) {
1331  5 continue;
1332    }
1333   
1334  18359 final FieldInfo fieldInfo = fieldDeser.fieldInfo;
1335  18359 Field field = fieldDeser.fieldInfo.field;
1336  18359 Type paramType = fieldInfo.fieldType;
1337   
1338  18359 if (field != null) {
1339  16322 Class fieldType = field.getType();
1340  16322 if (fieldType == boolean.class) {
1341  0 if (value == Boolean.FALSE) {
1342  0 field.setBoolean(object, false);
1343  0 continue;
1344    }
1345   
1346  0 if (value == Boolean.TRUE) {
1347  0 field.setBoolean(object, true);
1348  0 continue;
1349    }
1350  16322 } else if (fieldType == int.class) {
1351  6092 if (value instanceof Number) {
1352  6092 field.setInt(object, ((Number) value).intValue());
1353  6092 continue;
1354    }
1355  10230 } else if (fieldType == long.class) {
1356  3 if (value instanceof Number) {
1357  3 field.setLong(object, ((Number) value).longValue());
1358  3 continue;
1359    }
1360  10227 } else if (fieldType == float.class) {
1361  0 if (value instanceof Number) {
1362  0 field.setFloat(object, ((Number) value).floatValue());
1363  0 continue;
1364  0 } else if (value instanceof String) {
1365  0 String strVal = (String) value;
1366  0 float floatValue;
1367  0 if (strVal.length() <= 10) {
1368  0 floatValue = TypeUtils.parseFloat(strVal);
1369    } else {
1370  0 floatValue = Float.parseFloat(strVal);
1371    }
1372   
1373  0 field.setFloat(object, floatValue);
1374  0 continue;
1375    }
1376  10227 } else if (fieldType == double.class) {
1377  1 if (value instanceof Number) {
1378  1 field.setDouble(object, ((Number) value).doubleValue());
1379  1 continue;
1380  0 } else if (value instanceof String) {
1381  0 String strVal = (String) value;
1382  0 double doubleValue;
1383  0 if (strVal.length() <= 10) {
1384  0 doubleValue = TypeUtils.parseDouble(strVal);
1385    } else {
1386  0 doubleValue = Double.parseDouble(strVal);
1387    }
1388   
1389  0 field.setDouble(object, doubleValue);
1390  0 continue;
1391    }
1392  10226 } else if (value != null && paramType == value.getClass()) {
1393  2052 field.set(object, value);
1394  2052 continue;
1395    }
1396    }
1397   
1398  10211 String format = fieldInfo.format;
1399  10211 if (format != null && paramType == java.util.Date.class) {
1400  4 value = TypeUtils.castToDate(value, format);
1401    } else {
1402  10207 if (paramType instanceof ParameterizedType) {
1403  9 value = TypeUtils.cast(value, (ParameterizedType) paramType, config);
1404    } else {
1405  10198 value = TypeUtils.cast(value, paramType, config);
1406    }
1407    }
1408   
1409  10205 fieldDeser.setValue(object, value);
1410    }
1411   
1412  3645 if (beanInfo.buildMethod != null) {
1413  2 Object builtObj;
1414  2 try {
1415  2 builtObj = beanInfo.buildMethod.invoke(object);
1416    } catch (Exception e) {
1417  0 throw new JSONException("build object error", e);
1418    }
1419   
1420  2 return builtObj;
1421    }
1422   
1423  3643 return object;
1424    }
1425   
1426   
1427  8 FieldInfo[] fieldInfoList = beanInfo.fields;
1428  8 int size = fieldInfoList.length;
1429  8 Object[] params = new Object[size];
1430  8 Map<String, Integer> missFields = null;
1431  30 for (int i = 0; i < size; ++i) {
1432  22 FieldInfo fieldInfo = fieldInfoList[i];
1433  22 Object param = map.get(fieldInfo.name);
1434   
1435  22 if (param == null) {
1436  5 Class<?> fieldClass = fieldInfo.fieldClass;
1437  5 if (fieldClass == int.class) {
1438  1 param = 0;
1439  4 } else if (fieldClass == long.class) {
1440  0 param = 0L;
1441  4 } else if (fieldClass == short.class) {
1442  0 param = Short.valueOf((short) 0);
1443  4 } else if (fieldClass == byte.class) {
1444  0 param = Byte.valueOf((byte) 0);
1445  4 } else if (fieldClass == float.class) {
1446  0 param = Float.valueOf(0);
1447  4 } else if (fieldClass == double.class) {
1448  0 param = Double.valueOf(0);
1449  4 } else if (fieldClass == char.class) {
1450  0 param = '0';
1451  4 } else if (fieldClass == boolean.class) {
1452  0 param = false;
1453    }
1454  5 if (missFields == null) {
1455  3 missFields = new HashMap<String, Integer>();
1456    }
1457  5 missFields.put(fieldInfo.name, i);
1458    }
1459  22 params[i] = param;
1460    }
1461   
1462  8 if (missFields != null) {
1463  3 for (Map.Entry<String, Object> entry : map.entrySet()) {
1464  6 String key = entry.getKey();
1465  6 Object value = entry.getValue();
1466   
1467  6 FieldDeserializer fieldDeser = smartMatch(key);
1468  6 if (fieldDeser != null) {
1469  6 Integer index = missFields.get(fieldDeser.fieldInfo.name);
1470  6 if (index != null) {
1471  1 params[index] = value;
1472    }
1473    }
1474    }
1475    }
1476   
1477  8 if (beanInfo.creatorConstructor != null) {
1478  7 boolean hasNull = false;
1479  7 if (beanInfo.kotlin) {
1480  0 for (int i = 0; i < params.length; i++) {
1481  0 if (params[i] == null && beanInfo.fields != null && i < beanInfo.fields.length) {
1482  0 FieldInfo fieldInfo = beanInfo.fields[i];
1483  0 if (fieldInfo.fieldClass == String.class) {
1484  0 hasNull = true;
1485    }
1486  0 break;
1487    }
1488    }
1489    }
1490   
1491  7 if (hasNull && beanInfo.kotlinDefaultConstructor != null) {
1492  0 try {
1493  0 object = beanInfo.kotlinDefaultConstructor.newInstance();
1494   
1495  0 for (int i = 0; i < params.length; i++) {
1496  0 final Object param = params[i];
1497  0 if (param != null && beanInfo.fields != null && i < beanInfo.fields.length) {
1498  0 FieldInfo fieldInfo = beanInfo.fields[i];
1499  0 fieldInfo.set(object, param);
1500    }
1501    }
1502    } catch (Exception e) {
1503  0 throw new JSONException("create instance error, "
1504    + beanInfo.creatorConstructor.toGenericString(), e);
1505    }
1506    } else {
1507  7 try {
1508  7 object = beanInfo.creatorConstructor.newInstance(params);
1509    } catch (Exception e) {
1510  1 throw new JSONException("create instance error, "
1511    + beanInfo.creatorConstructor.toGenericString(), e);
1512    }
1513    }
1514  1 } else if (beanInfo.factoryMethod != null) {
1515  1 try {
1516  1 object = beanInfo.factoryMethod.invoke(null, params);
1517    } catch (Exception e) {
1518  1 throw new JSONException("create factory method error, " + beanInfo.factoryMethod.toString(), e);
1519    }
1520    }
1521   
1522  6 return object;
1523    }
1524   
 
1525  10000025 toggle public Type getFieldType(int ordinal) {
1526  10000025 return sortedFieldDeserializers[ordinal].fieldInfo.fieldType;
1527    }
1528   
 
1529  0 toggle protected Object parseRest(DefaultJSONParser parser, Type type, Object fieldName, Object instance, int features) {
1530  0 return parseRest(parser, type, fieldName, instance, features, new int[0]);
1531    }
1532   
 
1533  6014 toggle protected Object parseRest(DefaultJSONParser parser
1534    , Type type
1535    , Object fieldName
1536    , Object instance
1537    , int features
1538    , int[] setFlags) {
1539  6014 Object value = deserialze(parser, type, fieldName, instance, features, setFlags);
1540   
1541  6008 return value;
1542    }
1543   
 
1544  38 toggle protected JavaBeanDeserializer getSeeAlso(ParserConfig config, JavaBeanInfo beanInfo, String typeName) {
1545  38 if (beanInfo.jsonType == null) {
1546  23 return null;
1547    }
1548   
1549  15 for (Class<?> seeAlsoClass : beanInfo.jsonType.seeAlso()) {
1550  11 ObjectDeserializer seeAlsoDeser = config.getDeserializer(seeAlsoClass);
1551  11 if (seeAlsoDeser instanceof JavaBeanDeserializer) {
1552  11 JavaBeanDeserializer seeAlsoJavaBeanDeser = (JavaBeanDeserializer) seeAlsoDeser;
1553   
1554  11 JavaBeanInfo subBeanInfo = seeAlsoJavaBeanDeser.beanInfo;
1555  11 if (subBeanInfo.typeName.equals(typeName)) {
1556  7 return seeAlsoJavaBeanDeser;
1557    }
1558   
1559  4 JavaBeanDeserializer subSeeAlso = getSeeAlso(config, subBeanInfo, typeName);
1560  4 if (subSeeAlso != null) {
1561  1 return subSeeAlso;
1562    }
1563    }
1564    }
1565   
1566  7 return null;
1567    }
1568   
 
1569  8 toggle @SuppressWarnings({ "unchecked", "rawtypes" })
1570    protected static void parseArray(Collection collection, //
1571    ObjectDeserializer deser, //
1572    DefaultJSONParser parser, //
1573    Type type, //
1574    Object fieldName) {
1575   
1576  8 final JSONLexerBase lexer = (JSONLexerBase) parser.lexer;
1577  8 int token = lexer.token();
1578  8 if (token == JSONToken.NULL) {
1579  2 lexer.nextToken(JSONToken.COMMA);
1580  2 token = lexer.token();
1581  2 return;
1582    }
1583   
1584  6 if (token != JSONToken.LBRACKET) {
1585  0 parser.throwException(token);
1586    }
1587  6 char ch = lexer.getCurrent();
1588  6 if (ch == '[') {
1589  5 lexer.next();
1590  5 lexer.setToken(JSONToken.LBRACKET);
1591    } else {
1592  1 lexer.nextToken(JSONToken.LBRACKET);
1593    }
1594   
1595  6 if (lexer.token() == JSONToken.RBRACKET) {
1596  1 lexer.nextToken();
1597  1 return;
1598    }
1599   
1600  5 int index = 0;
1601  5 for (;;) {
1602  6 Object item = deser.deserialze(parser, type, index);
1603  6 collection.add(item);
1604  6 index++;
1605  6 if (lexer.token() == JSONToken.COMMA) {
1606  1 ch = lexer.getCurrent();
1607  1 if (ch == '[') {
1608  1 lexer.next();
1609  1 lexer.setToken(JSONToken.LBRACKET);
1610    } else {
1611  0 lexer.nextToken(JSONToken.LBRACKET);
1612    }
1613    } else {
1614  5 break;
1615    }
1616    }
1617   
1618  5 token = lexer.token();
1619  5 if (token != JSONToken.RBRACKET) {
1620  0 parser.throwException(token);
1621    }
1622   
1623  5 ch = lexer.getCurrent();
1624  5 if (ch == ',') {
1625  3 lexer.next();
1626  3 lexer.setToken(JSONToken.COMMA);
1627    } else {
1628  2 lexer.nextToken(JSONToken.COMMA);
1629    }
1630    // parser.accept(JSONToken.RBRACKET, JSONToken.COMMA);
1631    }
1632   
1633    }
  • Report generated by OpenClover v 4.5.2 on Tue Apr 9 2024 15:57:37 CDT using coverage data from Tue Apr 9 2024 15:57:18 CDT.
  • OpenClover is free and open-source software.